#ifndef _IVISITOR_H_
#define _IVISITOR_H_
#include "Object.h"

class Assert;
typedef QSharedPointer<Assert> AssertPtr;

class Assign;
typedef QSharedPointer<Assign> AssignPtr;

class Attribute;
typedef QSharedPointer<Attribute> AttributePtr;

class AugAssign;
typedef QSharedPointer<AugAssign> AugAssignPtr;

class BinOp;
typedef QSharedPointer<BinOp> BinOpPtr;

class BoolOp;
typedef QSharedPointer<BoolOp> BoolOpPtr;

class Break;
typedef QSharedPointer<Break> BreakPtr;

class Call;
typedef QSharedPointer<Call> CallPtr;

class ClassDef;
typedef QSharedPointer<ClassDef> ClassDefPtr;

class Compare;
typedef QSharedPointer<Compare> ComparePtr;

class Comprehension;
typedef QSharedPointer<Comprehension> ComprehensionPtr;

class Continue;
typedef QSharedPointer<Continue> ContinuePtr;

class Delete;
typedef QSharedPointer<Delete> DeletePtr;

class Dict;
typedef QSharedPointer<Dict> DictPtr;

class DictComp;
typedef QSharedPointer<DictComp> DictCompPtr;

class Ellipsis;
typedef QSharedPointer<Ellipsis> EllipsisPtr;

class Expr;
typedef QSharedPointer<Expr> ExprPtr;

class Expression;
typedef QSharedPointer<Expression> ExpressionPtr;

class ExtSlice;
typedef QSharedPointer<ExtSlice> ExtSlicePtr;

class For;
typedef QSharedPointer<For> ForPtr;

class FunctionDef;
typedef QSharedPointer<FunctionDef> FunctionDefPtr;

class GeneratorExp;
typedef QSharedPointer<GeneratorExp> GeneratorExpPtr;

class Global;
typedef QSharedPointer<Global> GlobalPtr;

class If;
typedef QSharedPointer<If> IfPtr;

class IfExp;
typedef QSharedPointer<IfExp> IfExpPtr;

class Import;
typedef QSharedPointer<Import> ImportPtr;

class ImportFrom;
typedef QSharedPointer<ImportFrom> ImportFromPtr;

class Index;
typedef QSharedPointer<Index> IndexPtr;

class Interactive;
typedef QSharedPointer<Interactive> InteractivePtr;

class Lambda;
typedef QSharedPointer<Lambda> LambdaPtr;

class List;
typedef QSharedPointer<List> ListPtr;

class ListComp;
typedef QSharedPointer<ListComp> ListCompPtr;

class Module;
typedef QSharedPointer<Module> ModulePtr;

class Name;
typedef QSharedPointer<Name> NamePtr;

class NameTok;
typedef QSharedPointer<NameTok> NameTokPtr;

class NonLocal;
typedef QSharedPointer<NonLocal> NonLocalPtr;

class Num;
typedef QSharedPointer<Num> NumPtr;

class Pass;
typedef QSharedPointer<Pass> PassPtr;

class Raise;
typedef QSharedPointer<Raise> RaisePtr;

class Repr;
typedef QSharedPointer<Repr> ReprPtr;

class Return;
typedef QSharedPointer<Return> ReturnPtr;

class Set;
typedef QSharedPointer<Set> SetPtr;

class SetComp;
typedef QSharedPointer<SetComp> SetCompPtr;

class Slice;
typedef QSharedPointer<Slice> SlicePtr;

class Starred;
typedef QSharedPointer<Starred> StarredPtr;

class Str;
typedef QSharedPointer<Str> StrPtr;

class StrJoin;
typedef QSharedPointer<StrJoin> StrJoinPtr;

class Subscript;
typedef QSharedPointer<Subscript> SubscriptPtr;

class TryExcept;
typedef QSharedPointer<TryExcept> TryExceptPtr;

class TryFinally;
typedef QSharedPointer<TryFinally> TryFinallyPtr;

class Tuple;
typedef QSharedPointer<Tuple> TuplePtr;

class UnaryOp;
typedef QSharedPointer<UnaryOp> UnaryOpPtr;

class While;
typedef QSharedPointer<While> WhilePtr;

class With;
typedef QSharedPointer<With> WithPtr;

class WithItem;
typedef QSharedPointer<WithItem> WithItemPtr;

class Yield;
typedef QSharedPointer<Yield> YieldPtr;
class Suite;
typedef QSharedPointer<Suite> SuitePtr;

class IVisitor
{
public:
    virtual void visitAssert( const AssertPtr &) = 0;
    virtual void visitAssign( const AssignPtr &) = 0;
    virtual void visitAttribute( const AttributePtr &) = 0;
    virtual void visitAugAssign( const AugAssignPtr &) = 0;
    virtual void visitBinOp( const BinOpPtr &) = 0;
    virtual void visitBoolOp( const BoolOpPtr &) = 0;
    virtual void visitBreak( const BreakPtr &) = 0;
    virtual void visitCall( const CallPtr &) = 0;
    virtual void visitClassDef( const ClassDefPtr &) = 0;
    virtual void visitCompare( const ComparePtr &) = 0;
    virtual void visitComprehension( const ComprehensionPtr &) = 0;
    virtual void visitContinue( const ContinuePtr &) = 0;
    virtual void visitDelete( const DeletePtr &) = 0;
    virtual void visitDict( const DictPtr &) = 0;
    virtual void visitDictComp( const DictCompPtr &) = 0;
    virtual void visitEllipsis( const EllipsisPtr &) = 0;
    virtual void visitExpr( const ExprPtr &) = 0;
    virtual void visitExpression( const ExpressionPtr &) = 0;
    virtual void visitExtSlice( const ExtSlicePtr &) = 0;
    virtual void visitFor( const ForPtr &) = 0;
    virtual void visitFunctionDef( const FunctionDefPtr &) = 0;
    virtual void visitGeneratorExp( const GeneratorExpPtr &) = 0;
    virtual void visitGlobal( const GlobalPtr &) = 0;
    virtual void visitIf( const IfPtr &) = 0;
    virtual void visitIfExp( const IfExpPtr &) = 0;
    virtual void visitImport( const ImportPtr &) = 0;
    virtual void visitImportFrom( const ImportFromPtr &) = 0;
    virtual void visitIndex( const IndexPtr &) = 0;
    virtual void visitInteractive( const InteractivePtr &) = 0;
    virtual void visitLambda( const LambdaPtr &) = 0;
    virtual void visitList( const ListPtr &) = 0;
    virtual void visitListComp( const ListCompPtr &) = 0;
    virtual void visitModule( const ModulePtr &) = 0;
    virtual void visitName( const NamePtr &) = 0;
    virtual void visitNameTok( const NameTokPtr &) = 0;
    virtual void visitNonLocal( const NonLocalPtr &) = 0;
    virtual void visitNum( const NumPtr &) = 0;
    virtual void visitPass( const PassPtr &) = 0;
    virtual void visitRaise( const RaisePtr &) = 0;
    virtual void visitRepr( const ReprPtr &) = 0;
    virtual void visitReturn( const ReturnPtr &) = 0;
    virtual void visitSet( const SetPtr &) = 0;
    virtual void visitSetComp( const SetCompPtr &) = 0;
    virtual void visitSlice( const SlicePtr &) = 0;
    virtual void visitStarred( const StarredPtr &) = 0;
    virtual void visitStr( const StrPtr &) = 0;
    virtual void visitStrJoin( const StrJoinPtr &) = 0;
    virtual void visitSubscript( const SubscriptPtr &) = 0;
    virtual void visitTryExcept( const TryExceptPtr &) = 0;
    virtual void visitTryFinally( const TryFinallyPtr &) = 0;
    virtual void visitTuple( const TuplePtr &) = 0;
    virtual void visitUnaryOp( const UnaryOpPtr &) = 0;
    virtual void visitWhile( const WhilePtr &) = 0;
    virtual void visitWith( const WithPtr &) = 0;
    virtual void visitWithItem( const WithItemPtr &) = 0;
    virtual void visitYield( const YieldPtr &) = 0;
    
    virtual void visitSuite(const SuitePtr &) = 0;
};
#endif